/*	
	Universidad: Universidad Nacional de Río Cuarto (UNRC)
	Materia: Taller de Diseño de Software (Cod. 3306)
	Carrera: Licenciatura en Ciencias de la Computación
	Proyecto 2011: Compilador de un subconjunto del lenguaje C (C--).
	Integrantes:
		Bettiol, Matías Nicolas.
		Mattana, Diego Leonel.
*/

%{

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../includes/Lista.h"
#include "../includes/Assembler.h"
#include "../includes/Pila.h"
#include "../includes/Cod3D.h"
#include "../includes/fun-main.h"

extern FILE *yyin;
extern char *yytext;
extern int yylineno;

// Mesaje de error.
void reportarToken(char* pLexema){
	printf("\nERROR: Linea %d: Expresión ' %s ' incorrecta. \n \n" ,yylineno, pLexema);
}

// Mensajes de warning.
void warning(char* a , char* b , char* c, char* d){
	if((a == "int") && (d == "float")){
			printf("\nWARNING: Linea %i: Incompatibilidad de tipos. '%s' es de tipo (int) y '%s' es de tipo (float).\n", yylineno,b,c);
			printf("(int) se escribe de la forma (x)\n");
			printf("(float) se escribe de la forma (x.x)\n\n");
	}
	else{
		if((a == "float") && (d == "int")){
			printf("\nWARNING: Linea %i: Incompatibilidad de tipos. '%s' es de tipo (float) y '%s' es de tipo (int).\n", yylineno,b,c);
			printf("(int) se escribe de la forma (x)\n");
			printf("(float) se escribe de la forma (x.x)\n\n");
		}
	}
}

Pila pila;
Lista nivel;
Lista labelif;
Lista labelWhile;
Lista labelPregunta;
Lista labelEndPregunta;
Lista lTemporales;
Cod3D codigo;
TElemLista elem, elemAux, labelElem, labelElemDos, elemTmp, *elemPregunta;

int tipoRetProgram;		
char* tipoCorriente;
char* tipoAuxiliar;
int l_if;
int l_while;
int l_pregunta;
int l_EndPregunta;
int temporal;
int cantLabels;
int offsetParam; // Los parametros son int positivos a partir de 8.
int offsetLocal; // Las variables locales son int negativos a partir de -4.
int cantOffset;
char* nombreFuncion;

%}

%union {
	char *variable;
	char *tipo;
	float valorF;
	int	valorI; 
	struct TElemLista *elemento;
}

%token asignacion ologico ilogico 
%token integer id flo dosPuntos
%token iguales menor mayor 
%token mas menos mult 
%token division resto complemento
%token negacion llaveCierra llaveAbre
%token finSentencia coma iniComentario 
%token pregunta finComentario
%token aParen cParen tipoF tipoI punto
%token si sino mientras retornar
%token continuar brek

%type <variable> id
%type <variable> integer
%type <variable> flo
%type <variable> tipoF
%type <variable> tipoI
%type <variable> Tipo
%type <elemento> Primary
%type <elemento> Expresion
%type <elemento> Variable
%type <elemento> Factor
%type <elemento> Term
%type <elemento> Condicion
%type <elemento> negacion
%type <elemento> complemento
%type <elemento> Comparacion
%type <elemento> Relacion
%type <elemento> Sum
%type <elemento> Conjuncion
%type <elemento> Disjuncion
%type <elemento> Condicional
%type <elemento> Iterador
%type <elemento> CondicionMientras
%type <elemento> Declaracion
%type <elemento> Rsino

%start Programa

%%

Programa : Tipo id aParen	{	if(strcmp($1, "int") == 0){
									tipoRetProgram = 1;
								}
								else{
									tipoRetProgram = 0;
								}
								labelWhile = openLista();
								labelif = openLista();
								codigo = openListaCodigo();
								pila = openPila(); 
								push(&pila,nivel);
								l_if = 0;
								l_while = 0;
								l_pregunta = 0;
								l_EndPregunta = 0;
								temporal = 0;
								offsetParam = 4;
								offsetLocal = 0;
								elemPregunta = malloc(sizeof(struct TElemLista));
								elemPregunta->nombre = "resPregunta";
								elemPregunta->constante = 1;
								nombreFuncion = $2;
							} 
			DeclaracionParamentros Componente	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
													TElemLista *labelUno = malloc(sizeof(struct TElemCodigo));
													TElemLista *labelDos = malloc(sizeof(struct TElemCodigo));
													labelUno->nombre = "";
													labelDos->nombre = "L_EndProgram";
									 	 			c3d->enumerado = "LABEL";
													c3d->opUno = labelDos;
													c3d->opDos = labelUno;
													c3d->resultado = labelUno;
													addCodigo3D(&codigo,*c3d);
													cantLabels = l_if + l_while;
												}

Componente : llaveAbre {push(&pila,nivel);} ListaVariable  ListaDeclaracion llaveCierra	{pop(&pila);}
           | llaveAbre  llaveCierra
           | llaveAbre ListaDeclaracion llaveCierra
           ;

DeclaracionParamentros : 
                       | Tipo id cParen	{	elem.nombre = $2; 
											elem.tipo = $1;
											elem.constante = 1;
											offsetParam = offsetParam + 4;
											elem.offset = offsetParam;
											pushElemento(&pila,elem);
											int tipoParam;
											if(strcmp($1, "int") == 0){
												tipoParam = 1;
											}
											else{
												tipoParam = 0;
											}
											insertarparam(tipoParam, elem.nombre);
										}
                       | Tipo id coma	{	elem.nombre = $2;
										 	elem.tipo = $1;
											elem.constante = 1;
											offsetParam = offsetParam + 4;
											elem.offset = offsetParam;
										 	pushElemento(&pila,elem);
											int tipoParam;
											if(strcmp($1, "int") == 0){
												tipoParam = 1;
											}
											else{
												tipoParam = 0;
											}
											insertarparam(tipoParam, elem.nombre);
										} 
						 DeclaracionParamentros	
                       ;

ListaVariable : Variable
			  | Variable ListaVariable
              ;

Variable : Tipo	ListaVar finSentencia	{}
		 ;

ListaVar : id	{	elem.nombre = $1;
			 		elem.tipo = tipoCorriente;
					elem.constante = 1;
					offsetLocal = offsetLocal - 4;
					elem.offset = offsetLocal;
					cantOffset = cantOffset + 1;
				 	pushElemento(&pila,elem);
				}
		 | id asignacion Expresion	{	elem.nombre = $1; 
										elem.tipo = tipoCorriente; 
										elem.valorI = $3->valorI;
										elem.valorF = $3->valorF;
										elem.constante = 1;
										offsetLocal = offsetLocal - 4;
										elem.offset = offsetLocal;
										cantOffset = cantOffset + 1;
										pushElemento(&pila,elem);
										if(strcmp(tipoCorriente, $3->tipo) != 0){
											printf("\nERROR: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n \n", yylineno,$1, $3->nombre);
											YYABORT;
										}
										TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
										TElemLista *aux = malloc(sizeof(struct TElemLista));
										TElemLista *auxDos = malloc(sizeof(struct TElemLista));
										aux->nombre = $1;
										aux->valorI = $3->valorI;
										aux->valorF = $3->valorF;
										aux->offset = elem.offset;
										auxDos->nombre = "";
									  	c3d->enumerado = "LD";
										c3d->opUno = aux;
										c3d->opDos = $3;
										c3d->resultado = auxDos;
										addCodigo3D(&codigo,*c3d);
									}
		 | id asignacion Expresion	{	elem.nombre = $1; 
										elem.tipo = tipoCorriente; 
										elem.valorI = $3->valorI;
										elem.valorF = $3->valorF;
										elem.constante = 1;
										offsetLocal = offsetLocal - 4;
										elem.offset = offsetLocal;
										cantOffset = cantOffset + 1;
										pushElemento(&pila,elem);
										if(strcmp(tipoCorriente, $3->tipo) != 0){
											printf("\nERROR: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n \n", yylineno,$1, $3->nombre);
											YYABORT;
										}
										TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
										TElemLista *aux = malloc(sizeof(struct TElemLista));
										TElemLista *auxDos = malloc(sizeof(struct TElemLista));
										aux->nombre = $1;
										aux->tipo = tipoCorriente;
										aux->valorI = $3->valorI;
										aux->valorF = $3->valorF;
										aux->offset = elem.offset;
										auxDos->nombre = "";
									  	c3d->enumerado = "LD";
										c3d->opUno = aux;
										c3d->opDos = $3;
										c3d->resultado = auxDos;
										addCodigo3D(&codigo,*c3d);
									}
		   coma ListaVar
		 | id coma ListaVar		{	elem.nombre = $1;
									elem.tipo = tipoCorriente;
									elem.constante = 1;
									offsetLocal = offsetLocal - 4;
									elem.offset = offsetLocal;
									cantOffset = cantOffset + 1;
									pushElemento(&pila,elem);
								}
		 ; 

ListaDeclaracion : Declaracion	{}
		         | Declaracion ListaDeclaracion	{}
		         ;

Declaracion : Componente		{}
	        | Condicional		{}
      		| Iterador			{}
      		| brek finSentencia	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
									TElemLista *labelAux = malloc(sizeof(struct TElemLista));
									TElemLista *labelAux2 = malloc(sizeof(struct TElemLista));
									Lista *aux;
									if(labelWhile != NULL){
										aux = &labelWhile;
									}
									labelAux2->nombre = "BREAK";
								  	c3d->enumerado = "JB";	// Salto condicional, salto por break.
									c3d->opUno = labelAux2;
									c3d->opDos = tope(aux);
									c3d->resultado = labelAux;
									addCodigo3D(&codigo,*c3d);
								}
      		| continuar finSentencia	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
											TElemLista *labelAux = malloc(sizeof(struct TElemLista));
											TElemLista *labelAux2 = malloc(sizeof(struct TElemLista));
											Lista *aux;
											if(labelWhile != NULL){
												aux = &labelWhile;
											}
											labelAux2->nombre = "CONTINUE";
										  	c3d->enumerado = "JC";	// Salto condicional, salto por continue.
											c3d->opUno = labelAux2;
											c3d->opDos = subTope(aux);
											c3d->resultado = labelAux;
											addCodigo3D(&codigo,*c3d);
										}
      		| retornar Expresion finSentencia	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
													TElemLista *labelUno = malloc(sizeof(struct TElemLista));
													TElemLista *labelDos = malloc(sizeof(struct TElemLista));
													labelUno->nombre = "";
													labelDos = $2;
													c3d->enumerado = "RET";
													c3d->opUno = labelUno;
													c3d->opDos = labelDos;
													c3d->resultado = labelUno;
													addCodigo3D(&codigo,*c3d);
													$$ = $2;
													// Se redefine para evitar conflictos.
													TElemCodigo *c3dDos = malloc(sizeof(struct TElemCodigo));
													TElemLista *labelAux = malloc(sizeof(struct TElemLista));
													TElemLista *labelAuxDos = malloc(sizeof(struct TElemLista));
													labelAux->nombre = "";
													labelAuxDos->nombre = "L_EndProgram";
													c3d->enumerado = "JMP";	// Salto incondicional.
													c3d->opUno = labelAuxDos;
													c3d->opDos = labelAux;
													c3d->resultado = labelAux;
													addCodigo3D(&codigo,*c3d);
												}
      		| Expresion finSentencia			{$$ = $1;}
			;

Condicional : si aParen Expresion	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
										TElemLista *labelAux = malloc(sizeof(struct TElemLista));
										l_if = l_if++;
										labelElem.label  = l_if;
										labelElem.nombre = "L_if";
										add(&labelif,labelElem);
										l_if = l_if++;
										labelElem.label  = l_if;
										labelElem.nombre = "L_if";
										add(&labelif,labelElem);
										Lista aux;
										c3d->enumerado = "JN";	// Salto condicional, salto por negativo.
										c3d->opUno = $3;
										c3d->opDos = findElemento(labelif,labelElem,&aux);
										c3d->resultado = labelAux;
										addCodigo3D(&codigo,*c3d);
									} 
			  cParen Declaracion	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
										TElemLista *labelAux = malloc(sizeof(struct TElemLista));
										labelAux->nombre="";
										Lista *aux;
										c3d->enumerado = "JMP";	// Salto incondicional.
										aux = &labelif;													
										c3d->opUno = subTope(aux);
										c3d->opDos = labelAux;
										c3d->resultado = labelAux;
										addCodigo3D(&codigo,*c3d);
									}
			  Rsino	{	popLista(&labelif);
						popLista(&labelif);
					}
			;

Rsino :	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
			TElemLista *labelAux = malloc(sizeof(struct TElemLista));
			Lista *aux ;
			aux = &labelif;
			labelAux->nombre = "";
		  	c3d->enumerado = "LABEL";
			c3d->opUno = tope(aux);
			c3d->opDos = labelAux;
			c3d->resultado = labelAux;
			addCodigo3D(&codigo,*c3d);
			// Se redefine para evitar conflictos.
			TElemCodigo *c3dDos = malloc(sizeof(struct TElemCodigo));
			TElemLista *labelAuxDos = malloc(sizeof(struct TElemLista));
			Lista *auxDos;
			auxDos = &labelif;
			c3dDos->enumerado = "LABEL";
			c3dDos->opUno = subTope(auxDos);
			c3dDos->opDos = labelAuxDos;
			c3dDos->resultado = labelAuxDos;
			addCodigo3D(&codigo,*c3dDos);
		}
	  | sino	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
					TElemLista *labelAux = malloc(sizeof(struct TElemLista));
					Lista *aux ;
					aux = &labelif;
					labelAux->nombre = "";
				  	c3d->enumerado = "LABEL";
					c3d->opUno = tope(aux);
					c3d->opDos = labelAux;
					c3d->resultado = labelAux;
					addCodigo3D(&codigo,*c3d);
				}
		Declaracion	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
						TElemLista *labelAux = malloc(sizeof(struct TElemLista));
						Lista *aux ;
						aux = &labelif;
					  	c3d->enumerado = "LABEL";
						c3d->opUno = subTope(aux);
						c3d->opDos = labelAux;
						c3d->resultado = labelAux;
						addCodigo3D(&codigo,*c3d);
					}
      ;

Iterador : mientras	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
						TElemLista *labelAux = malloc(sizeof(struct TElemLista));
						l_while = l_while++;
						labelElem.label  = l_while;
						labelElem.nombre = "L_while";
						add(&labelWhile,labelElem);
						Lista aux;
						c3d->enumerado = "LABEL";
						c3d->opUno = findElemento(labelWhile,labelElem,&aux);
						c3d->opDos = labelAux;
						c3d->resultado = labelAux;
						addCodigo3D(&codigo,*c3d);
						l_while = l_while++;
						labelElem.label  = l_while;
						labelElem.nombre = "L_while";
						add(&labelWhile,labelElem);
					} 
			CondicionMientras Declaracion	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
												TElemLista *labelAux = malloc(sizeof(struct TElemLista));
												labelAux->nombre="";
												Lista *aux;
												aux = &labelWhile;
											  	c3d->enumerado = "JMP";	// Salto incondicional.
												c3d->opUno = subTope(aux);
												c3d->opDos = labelAux;
												c3d->resultado = labelAux;
												addCodigo3D(&codigo,*c3d);
												// Se redefine el nombre de las varibles para evitar conflictos.
												TElemCodigo *c3d2 = malloc(sizeof(struct TElemCodigo));
												TElemLista *labelAux2 = malloc(sizeof(struct TElemLista));
												labelAux2->nombre = "";
											  	c3d2->enumerado = "LABEL";
												c3d2->opUno = tope(aux);
												c3d2->opDos = labelAux2;
												c3d2->resultado = labelAux2;
												addCodigo3D(&codigo,*c3d2);
												popLista(&labelWhile);
												popLista(&labelWhile);
											}
		;

CondicionMientras :	aParen Expresion cParen	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
												TElemLista *labelAux = malloc(sizeof(struct TElemLista));
												Lista *aux;
												aux = &labelWhile;	
											  	c3d->enumerado = "JN";	// Salto condicional, salto por negativo.
												c3d->opUno = $2;
												c3d->opDos = tope(aux);
												c3d->resultado = labelAux;
												addCodigo3D(&codigo,*c3d);
											}
				  ;

Expresion : id asignacion Expresion	{	elem.nombre = $1;
										if(buscarElemento(&pila,elem)!= 0){
											printf("\nERROR: Linea %i: Simbolo '%s' indefinido, variable no declarada. \n\n", yylineno, $1);
											YYABORT;
										}	
										char* aux1 = (char*) buscarTipo(&pila,$1);
										if(strcmp(aux1, $3->tipo) != 0){
											printf("\nERROR: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n\n", yylineno,$1, $3->nombre);
											YYABORT;
										}
										TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
										TElemLista *aux = malloc(sizeof(struct TElemLista));
										TElemLista *auxDos = malloc(sizeof(struct TElemLista));
										auxDos = retornaElemento(&pila,elem);
										auxDos->valorI = $3->valorI;
										auxDos->valorF = $3->valorF;
										aux->nombre = "";
									  	c3d->enumerado = "LD";
										c3d->opUno = auxDos;
										c3d->opDos = $3;
										c3d->resultado = aux;
										addCodigo3D(&codigo,*c3d);
										$$ = auxDos;
									}
		  | Condicion	{$$ = $1;}
		  ;

Condicion : Disjuncion	{$$ = $1;}
	      | Disjuncion pregunta	{	// a ? b : c
									// IF a
									TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
									TElemLista *labelAux = malloc(sizeof(struct TElemLista));
									// label para b y c
									l_pregunta = l_pregunta++;
									labelElem.label  = l_pregunta;
									labelElem.nombre = "L_pregunta";
									add(&labelPregunta,labelElem);
									// label endPregunta
									l_EndPregunta = l_EndPregunta++;
									labelElemDos.label  = l_EndPregunta;
									labelElemDos.nombre = "L_EndPregunta";
									add(&labelEndPregunta,labelElemDos);
									labelAux->nombre = "";
									Lista aux;
									c3d->enumerado = "JN";	// Salto condicional, salto por negativo.
									c3d->opUno = $1;
									c3d->opDos = findElemento(labelPregunta,labelElem,&aux);
									c3d->resultado = labelAux;
									addCodigo3D(&codigo,*c3d);
								}
			Expresion	{	TElemCodigo *c3dUno = malloc(sizeof(struct TElemCodigo));
							TElemLista *labelUno = malloc(sizeof(struct TElemLista));
							labelUno->nombre = "";
							elemPregunta->nombre = "resPregunta";
							elemPregunta->tipo = $4->tipo;
							elemPregunta->valorI = $4->valorI;
							elemPregunta->valorF = $4->valorF;
							offsetLocal = offsetLocal - 4;
							elemPregunta->offset = offsetLocal;
							elemPregunta->constante = 1;
							c3dUno->enumerado = "LD";
							c3dUno->opUno = elemPregunta;
							c3dUno->opDos = $4;
							c3dUno->resultado = labelUno;
							addCodigo3D(&codigo,*c3dUno);
							// Se redefinen nombres para evitar conflictos.
							TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
							TElemLista *labelAux = malloc(sizeof(struct TElemLista));
							Lista *aux;
							aux = &labelEndPregunta;
							labelAux->nombre = "";
							c3dAux->enumerado = "JMP";	// Salto incondicional.
							c3dAux->opUno = tope(aux);
							c3dAux->opDos = labelAux;
							c3dAux->resultado = labelAux;
							addCodigo3D(&codigo,*c3dAux);
						} 

			dosPuntos	{	TElemCodigo *c3dTres = malloc(sizeof(struct TElemCodigo));
							TElemLista *labelAuxDos = malloc(sizeof(struct TElemLista));
							Lista *auxDos ;
							auxDos = &labelPregunta;
							labelAuxDos->nombre = "";
							c3dTres->enumerado = "LABEL";
							c3dTres->opUno = tope(auxDos);
							c3dTres->opDos = labelAuxDos;
							c3dTres->resultado = labelAuxDos;
							addCodigo3D(&codigo,*c3dTres);
						}
			Condicion	{	TElemCodigo *c3dUno = malloc(sizeof(struct TElemCodigo));
							TElemLista *labelUno = malloc(sizeof(struct TElemLista));
							labelUno->nombre = "";
							elemPregunta->nombre = "resPregunta";
							elemPregunta->tipo = $8->tipo;
							elemPregunta->valorI = $8->valorI;
							elemPregunta->valorF = $8->valorF;
							offsetLocal = offsetLocal - 4;
							elemPregunta->offset = offsetLocal;
							elemPregunta->constante = 1;
							c3dUno->enumerado = "LD";
							c3dUno->opUno = elemPregunta;
							c3dUno->opDos = $8;
							c3dUno->resultado =labelUno;
							addCodigo3D(&codigo,*c3dUno);
							// Se redefine para evitar conflictos.
							TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
							TElemLista *labelAux = malloc(sizeof(struct TElemLista));
							Lista *aux;
							aux = &labelEndPregunta;
							labelAux->nombre = "";
							c3dAux->enumerado = "JMP";	// Salto incondicional.
							c3dAux->opUno = tope(aux);
							c3dAux->opDos = labelAux;
							c3dAux->resultado = labelAux;
							addCodigo3D(&codigo,*c3dAux);
							// Se redefine para evitar conflictos.
							TElemCodigo *c3dTres = malloc(sizeof(struct TElemCodigo));
							TElemLista *labelAuxTres = malloc(sizeof(struct TElemLista));
							Lista *auxDos;
							auxDos = &labelEndPregunta;
							labelAuxTres->nombre = "";
							c3dTres->enumerado = "LABEL"; // Salto incondicional.
							c3dTres->opUno = tope(auxDos);
							c3dTres->opDos = labelAuxTres;
							c3dTres->resultado = labelAuxTres;
							addCodigo3D(&codigo,*c3dTres);
							cantOffset = cantOffset + 1;
							$$ = elemPregunta;
							popLista(&labelPregunta);
							popLista(&labelEndPregunta);
						}
		  ;

Disjuncion : Conjuncion	{$$ = $1;}
		   | Disjuncion ologico Conjuncion
				{	if(strcmp($1->tipo, $3->tipo) != 0){
						printf("\nERROR: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n\n", yylineno,$1->nombre, $3->nombre);
						YYABORT;
					}
					TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
					char *buffer = malloc(sizeof(char)*10);
					temporal = temporal++;
					elemTmp.label  = temporal;
					sprintf(buffer,"%d",temporal);
					char *bufferAux = malloc(sizeof(char)*10);
					strcpy(bufferAux,"Tmp");
					elemTmp.nombre = strcat(bufferAux,buffer);
					elemTmp.tipo = $1->tipo;
					if(strcmp($1->tipo,"int") == 0)
						elemTmp.valorI = $1->valorI || $3->valorI;
					else
						elemTmp.valorF = $1->valorF || $3->valorF;
					offsetLocal = offsetLocal - 4;
					elemTmp.offset = offsetLocal;
					elemTmp.constante = 1;
					add(&lTemporales,elemTmp);
					Lista aux;
		 			c3d->enumerado = "OR";
					c3d->opUno = $1;
					c3d->opDos = $3;
					c3d->resultado = findElemento(lTemporales,elemTmp,&aux);
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3d);
					$$ = findElemento(lTemporales,elemTmp,&aux);
				}	  
           ;

Conjuncion : Comparacion	{$$ = $1;}
           | Conjuncion ilogico Comparacion
				{	if(strcmp($1->tipo, $3->tipo) != 0){
						printf("\nERROR: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n\n", yylineno,$1->nombre, $3->nombre);
						YYABORT;
					}
					TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
					TElemLista *res = malloc(sizeof(struct TElemLista));
					res->nombre = "Tmp";
					res->constante = 1 ;
					offsetLocal = offsetLocal - 4;
					res->offset = offsetLocal;
					res->tipo = $1->tipo;
					if(strcmp($1->tipo,"int") == 0)
						res->valorI = $1->valorI && $3->valorI;
					else
						res->valorF = $1->valorF && $3->valorF;
		 			c3d->enumerado = "AND";
					c3d->opUno = $1;
					c3d->opDos = $3;
					c3d->resultado = res;
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3d);
					$$ = res;
				}
           ;

Comparacion : Relacion	{$$ = $1;}
		    | Relacion iguales Relacion 	
				{	if(strcmp($1->tipo,$3->tipo) != 0){
						printf("\nWARNING: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n\n", yylineno,$1->nombre,$3->nombre);
						if(strcmp($1->tipo,"int") == 0){
							TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
							TElemLista *resAux = malloc(sizeof(struct TElemLista));
							TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
							resAux2->nombre = "";
							resAux->nombre = "Tmp";
							resAux->constante = 1 ;
							offsetLocal = offsetLocal - 4;
							resAux->offset = offsetLocal;
							resAux->tipo = $3->tipo;
		 					c3dAux->enumerado = "CAST";
							c3dAux->opUno = $1;
							c3dAux->opDos = resAux2;
							c3dAux->resultado = resAux;
							cantOffset = cantOffset + 1;
							addCodigo3D(&codigo,*c3dAux);
							$1 = resAux;
						}
						else{
							TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
							TElemLista *resAux = malloc(sizeof(struct TElemLista));
							TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
							resAux2->nombre = "";
							resAux->nombre = "Tmp";
							resAux->constante = 1 ;
							offsetLocal = offsetLocal - 4;
							resAux->offset = offsetLocal;
							resAux->tipo = $1->tipo;
		 					c3dAux->enumerado = "CAST";
							c3dAux->opUno = $3;
							c3dAux->opDos = resAux2;
							c3dAux->resultado = resAux;
							cantOffset = cantOffset + 1;
							addCodigo3D(&codigo,*c3dAux);
							$3 = resAux;
						}
					}
					TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
					TElemLista *res = malloc(sizeof(struct TElemLista));
					res->nombre = "Tmp";
					res->constante = 1 ;
					offsetLocal = offsetLocal - 4;
					res->offset = offsetLocal;
					res->tipo = $1->tipo;
					if(strcmp($1->tipo,"int") == 0)
						res->valorI = $1->valorI == $3->valorI;
					else
						res->valorF = $1->valorF == $3->valorF;
		 			c3d->enumerado = "CMPigual";
					c3d->opUno = $1;
					c3d->opDos = $3;
					c3d->resultado = res;
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3d);
					$$ = res;
				}
			;

Relacion : Sum	{$$ = $1;}
		 | Sum menor Sum
			{	if(strcmp($1->tipo,$3->tipo) != 0){
					printf("\nWARNING: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n\n", yylineno,$1->nombre,$3->nombre);
					if(strcmp($1->tipo,"int") == 0){
						TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
						TElemLista *resAux = malloc(sizeof(struct TElemLista));
						TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
						resAux2->nombre = "";
						resAux->nombre = "Tmp";
						resAux->constante = 1 ;
						offsetLocal = offsetLocal - 4;
						resAux->offset = offsetLocal;
						resAux->tipo = $3->tipo;
 						c3dAux->enumerado = "CAST";
						c3dAux->opUno = $1;
						c3dAux->opDos = resAux2;
						c3dAux->resultado = resAux;
						cantOffset = cantOffset + 1;
						addCodigo3D(&codigo,*c3dAux);
						$1 = resAux;
					}
					else{
						TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
						TElemLista *resAux = malloc(sizeof(struct TElemLista));
						TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
						resAux2->nombre = "";
						resAux->nombre = "Tmp";
						resAux->constante = 1 ;
						offsetLocal = offsetLocal - 4;
						resAux->offset = offsetLocal;
						resAux->tipo = $1->tipo;
 						c3dAux->enumerado = "CAST";
						c3dAux->opUno = $3;
						c3dAux->opDos = resAux2;
						c3dAux->resultado = resAux;
						cantOffset = cantOffset + 1;
						addCodigo3D(&codigo,*c3dAux);
						$3 = resAux;
					}
				}
				TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
				TElemLista *res = malloc(sizeof(struct TElemLista));
				res->nombre = "Tmp";
				res->constante = 1 ;
				offsetLocal = offsetLocal - 4;
				res->offset = offsetLocal;
				res->tipo = $1->tipo;
				if(strcmp($1->tipo,"int") == 0)
					res->valorI = $1->valorI < $3->valorI;
				else
					res->valorF = $1->valorF < $3->valorF;
	 			c3d->enumerado = "CMPmenor";
				c3d->opUno = $1;
				c3d->opDos = $3;
				c3d->resultado = res;
				cantOffset = cantOffset + 1;
				addCodigo3D(&codigo,*c3d);
				$$ = res;
			}				
		 | Sum mayor Sum
			{	if(strcmp($1->tipo,$3->tipo) != 0){
					printf("\nWARNING: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n\n", yylineno,$1->nombre,$3->nombre);
					if(strcmp($1->tipo,"int") == 0){
						TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
						TElemLista *resAux = malloc(sizeof(struct TElemLista));
						TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
						resAux2->nombre = "";
						resAux->nombre = "Tmp";
						resAux->constante = 1 ;
						offsetLocal = offsetLocal - 4;
						resAux->offset = offsetLocal;
						resAux->tipo = $3->tipo;
 						c3dAux->enumerado = "CAST";
						c3dAux->opUno = $1;
						c3dAux->opDos = resAux2;
						c3dAux->resultado = resAux;
						cantOffset = cantOffset + 1;
						addCodigo3D(&codigo,*c3dAux);
						$1 = resAux;
					}
					else{
						TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
						TElemLista *resAux = malloc(sizeof(struct TElemLista));
						TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
						resAux2->nombre = "";
						resAux->nombre = "Tmp";
						resAux->constante = 1 ;
						offsetLocal = offsetLocal - 4;
						resAux->offset = offsetLocal;
						resAux->tipo = $1->tipo;
 						c3dAux->enumerado = "CAST";
						c3dAux->opUno = $3;
						c3dAux->opDos = resAux2;
						c3dAux->resultado = resAux;
						cantOffset = cantOffset + 1;
						addCodigo3D(&codigo,*c3dAux);
						$3 = resAux;
					}
				}
				TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
				TElemLista *res = malloc(sizeof(struct TElemLista));
				res->nombre = "Tmp";
				res->constante = 1 ;				
				offsetLocal = offsetLocal - 4;
				res->offset = offsetLocal;
				res->tipo = $1->tipo;
				if(strcmp($1->tipo,"int") == 0)
					res->valorI = $1->valorI > $3->valorI;
				else
					res->valorF = $1->valorF > $3->valorF;
	 			c3d->enumerado = "CMPmayor";
				c3d->opUno = $1;
				c3d->opDos = $3;
				c3d->resultado = res;
				cantOffset = cantOffset + 1;
				addCodigo3D(&codigo,*c3d);
				$$ = res;
			}
		 ;

Sum : Term	{$$ = $1;}
	| Sum mas Term 	
		{	if(strcmp($1->tipo,$3->tipo) != 0){
				printf("\nWARNING: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n\n", yylineno,$1->nombre,$3->nombre);
				if(strcmp($1->tipo,"int") == 0){
					TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
					TElemLista *resAux = malloc(sizeof(struct TElemLista));
					TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
					resAux2->nombre = "";
					resAux->nombre = "Tmp";
					resAux->constante = 1 ;
					offsetLocal = offsetLocal - 4;
					resAux->offset = offsetLocal;
					resAux->tipo = $3->tipo;
 					c3dAux->enumerado = "CAST";
					c3dAux->opUno = $1;
					c3dAux->opDos = resAux2;
					c3dAux->resultado = resAux;
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3dAux);
					$1 = resAux;
				}
				else{
					TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
					TElemLista *resAux = malloc(sizeof(struct TElemLista));
					TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
					resAux2->nombre = "";
					resAux->nombre = "Tmp";
					resAux->constante = 1 ;
					offsetLocal = offsetLocal - 4;
					resAux->offset = offsetLocal;
					resAux->tipo = $1->tipo;
 					c3dAux->enumerado = "CAST";
					c3dAux->opUno = $3;
					c3dAux->opDos = resAux2;
					c3dAux->resultado = resAux;
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3dAux);
					$3 = resAux;
				}
			}
			TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
			TElemLista *res = malloc(sizeof(struct TElemLista));
			res->nombre = "Tmp";
			res->constante = 1 ;
			offsetLocal = offsetLocal - 4;
			res->offset = offsetLocal;
			res->tipo = $1->tipo;
			if(strcmp($1->tipo,"int") == 0)
				res->valorI = $1->valorI + $3->valorI;
			else
				res->valorF = $1->valorF + $3->valorF;
 			c3d->enumerado = "ADD";
			c3d->opUno = $1;
			c3d->opDos = $3;
			c3d->resultado = res;
			cantOffset = cantOffset + 1;
			addCodigo3D(&codigo,*c3d);
			$$ = res;
		}
	| Sum negacion Term	
		{	if(strcmp($1->tipo,$3->tipo) != 0){
				printf("\nWARNING: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n \n", yylineno,$1->nombre,$3->nombre);
				if(strcmp($1->tipo,"int") == 0){
					TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
					TElemLista *resAux = malloc(sizeof(struct TElemLista));
					TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
					resAux2->nombre = "";
					resAux->nombre = "Tmp";
					resAux->constante = 1 ;
					offsetLocal = offsetLocal - 4;
					resAux->offset = offsetLocal;
					resAux->tipo = $3->tipo;
 					c3dAux->enumerado = "CAST";
					c3dAux->opUno = $1;
					c3dAux->opDos = resAux2;
					c3dAux->resultado = resAux;
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3dAux);
					$1 = resAux;
				}
				else{
					TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
					TElemLista *resAux = malloc(sizeof(struct TElemLista));
					TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
					resAux2->nombre = "";
					resAux->nombre = "Tmp";
					resAux->constante = 1 ;
					offsetLocal = offsetLocal - 4;
					resAux->offset = offsetLocal;
					resAux->tipo = $1->tipo;
 					c3dAux->enumerado = "CAST";
					c3dAux->opUno = $3;
					c3dAux->opDos = resAux2;
					c3dAux->resultado = resAux;
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3dAux);
					$3 = resAux;
				}
			}
			TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
			TElemLista *res = malloc(sizeof(struct TElemLista));
			res->nombre = "Tmp";
			res->constante = 1 ;
			offsetLocal = offsetLocal - 4;
			res->offset = offsetLocal;
			res->tipo = $1->tipo;
			if(strcmp($1->tipo,"int") == 0)
				res->valorI = $1->valorI - $3->valorI;
			else
				res->valorF = $1->valorF - $3->valorF;
 			c3d->enumerado = "SUB";
			c3d->opUno = $1;
			c3d->opDos = $3;
			c3d->resultado = res;
			cantOffset = cantOffset + 1;
			addCodigo3D(&codigo,*c3d);
			$$ = res;
		}
	;

Term : Factor	{$$ = $1;}
	 | Term mult Factor 
		{	if(strcmp($1->tipo,$3->tipo) != 0){
				printf("\nWARNING: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n \n", yylineno,$1->nombre,$3->nombre);
				if(strcmp($1->tipo,"int") == 0){
					TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
					TElemLista *resAux = malloc(sizeof(struct TElemLista));
					TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
					resAux2->nombre = "";
					resAux->nombre = "Tmp";
					resAux->constante = 1 ;
					offsetLocal = offsetLocal - 4;
					resAux->offset = offsetLocal;
					resAux->tipo = $3->tipo;
 					c3dAux->enumerado = "CAST";
					c3dAux->opUno = $1;
					c3dAux->opDos = resAux2;
					c3dAux->resultado = resAux;
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3dAux);
					$1 = resAux;
				}
				else{
					TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
					TElemLista *resAux = malloc(sizeof(struct TElemLista));
					TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
					resAux2->nombre = "";
					resAux->nombre = "Tmp";
					resAux->constante = 1 ;
					offsetLocal = offsetLocal - 4;
					resAux->offset = offsetLocal;
					resAux->tipo = $1->tipo;
 					c3dAux->enumerado = "CAST";
					c3dAux->opUno = $3;
					c3dAux->opDos = resAux2;
					c3dAux->resultado = resAux;
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3dAux);
					$3 = resAux;
				}
			}
			TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
			TElemLista *res = malloc(sizeof(struct TElemLista));
			res->nombre = "Tmp";
			res->constante = 1 ;
			offsetLocal = offsetLocal - 4;
			res->offset = offsetLocal;
			res->tipo = $1->tipo;
			if(strcmp($1->tipo,"int") == 0)
				res->valorI = $1->valorI * $3->valorI;
			else
				res->valorF = $1->valorF * $3->valorF;
			c3d->enumerado = "MULT";
			c3d->opUno = $1;
			c3d->opDos = $3;
			c3d->resultado = res;
			cantOffset = cantOffset + 1;
			addCodigo3D(&codigo,*c3d);
			$$ = res;
		}						
	 | Term division Factor	
		{	if(strcmp($1->tipo,$3->tipo) != 0){
				printf("\nWARNING: Linea %i: '%s' y '%s' se usan en la misma expresión pero no son del mismo TIPO. \n \n", yylineno,$1->nombre,$3->nombre);
				if(strcmp($1->tipo,"int") == 0){
					TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
					TElemLista *resAux = malloc(sizeof(struct TElemLista));
					TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
					resAux2->nombre = "";
					resAux->nombre = "Tmp";
					resAux->constante = 1 ;
					offsetLocal = offsetLocal - 4;
					resAux->offset = offsetLocal;
					resAux->tipo = $3->tipo;
 					c3dAux->enumerado = "CAST";
					c3dAux->opUno = $1;
					c3dAux->opDos = resAux2;
					c3dAux->resultado = resAux;
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3dAux);
					$1 = resAux;
				}
				else{
					TElemCodigo *c3dAux = malloc(sizeof(struct TElemCodigo));
					TElemLista *resAux = malloc(sizeof(struct TElemLista));
					TElemLista *resAux2 = malloc(sizeof(struct TElemLista));
					resAux2->nombre = "";
					resAux->nombre = "Tmp";
					resAux->constante = 1 ;
					offsetLocal = offsetLocal - 4;
					resAux->offset = offsetLocal;
					resAux->tipo = $1->tipo;
 					c3dAux->enumerado = "CAST";
					c3dAux->opUno = $3;
					c3dAux->opDos = resAux2;
					c3dAux->resultado = resAux;
					cantOffset = cantOffset + 1;
					addCodigo3D(&codigo,*c3dAux);
					$3 = resAux;
				}
			}
			TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
			TElemLista *res = malloc(sizeof(struct TElemLista));
			res->nombre = "Tmp";
			res->constante = 1 ;
			offsetLocal = offsetLocal - 4;
			res->offset = offsetLocal;
			res->tipo = $1->tipo;
			if(strcmp($1->tipo,"int") == 0)
				res->valorI = $1->valorI / $3->valorI;
			else
				res->valorF = $1->valorF / $3->valorF;
	 		c3d->enumerado = "DIV";
			c3d->opUno = $1;
			c3d->opDos = $3;
			c3d->resultado = res;
			cantOffset = cantOffset + 1;
			addCodigo3D(&codigo,*c3d);
			$$ = res;
		}						
	 | Term resto Factor
		{	if((strcmp($1->tipo,"float") == 0)  || (strcmp($3->tipo,"float") == 0)   )     {
	 			printf("\nERROR: Linea %i: No se puede apĺicar Modulo en variables de tipo float \n \n", yylineno);
			   	YYABORT;
			}
			TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
			TElemLista *res = malloc(sizeof(struct TElemLista));
			res->nombre = "Tmp";
			res->constante = 1 ;
			offsetLocal = offsetLocal - 4;
			res->offset = offsetLocal;
			res->tipo = $1->tipo;
			res->valorI = $1->valorI % $3->valorI;
		 	c3d->enumerado = "MOD";
			c3d->opUno = $1;
			c3d->opDos = $3;
			c3d->resultado = res;
			cantOffset = cantOffset + 1;
			addCodigo3D(&codigo,*c3d);
			$$ = res;
		}
	 ;

Factor : Primary	{$$ = $1;}
	   | complemento Factor	
			{	if (strcmp($2->tipo,"int") != 0){
					printf("\nERROR: Linea %i: Simbolo '%s' no es de tipo <int>, imposible realizar complemento. \n \n", yylineno,$2->nombre);
			       	YYABORT;
				}
				TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
				TElemLista *res = malloc(sizeof(struct TElemLista));
				TElemLista *aux = malloc(sizeof(struct TElemLista));
				offsetLocal = offsetLocal - 4;
				cantOffset = cantOffset + 1;
				res->nombre = "Tmp";
				res->constante = 1 ;
				res->tipo = $2->tipo;
				res->valorI = $2->valorI * (-1);
				res->offset = offsetLocal;
				aux->nombre = "";
			 	c3d->enumerado = "COMP";
				c3d->opUno = $2;
				c3d->opDos = aux;
				c3d->resultado = res;
				addCodigo3D(&codigo,*c3d);
				$$ = res;
			}	
	   	| negacion Factor	{	TElemCodigo *c3d = malloc(sizeof(struct TElemCodigo));
								TElemLista *res = malloc(sizeof(struct TElemLista));
								TElemLista *aux = malloc(sizeof(struct TElemLista));
								offsetLocal = offsetLocal - 4;
								res->nombre = "Tmp";
								res->constante = 1 ;
								if ($2->tipo == "int"){
									res->valorI = $2->valorI * (-1);
									res->tipo = "int";
								}
								else{
									res->valorF = $2->valorF * (-1);								
									res->tipo = "float";
								}
								res->offset = offsetLocal;
								aux->nombre = "";
			 					c3d->enumerado = "NEG";
								c3d->opUno = $2;
								c3d->opDos = aux;
								c3d->resultado = res;
								cantOffset = cantOffset + 1;
								addCodigo3D(&codigo,*c3d);
								$$ = res;
							}
	    ;

Primary : integer	{ 	$$ = malloc(sizeof(struct TElemLista));
						$$->nombre = $1;	
						$$->valorI = atoi ((char*)$1);
						$$->constante = 0;
					  	$$->tipo = "int";
					}
	    | flo		{	$$ = malloc(sizeof(struct TElemLista));
					 	$$->nombre = $1;
						$$->constante = 0;
					 	$$->valorF = atof ((char*)$1);						
					 	$$->tipo = "float";
					}
	    | id		{	TElemLista *elementos = malloc(sizeof(struct TElemLista));
						elem.nombre = $1;
						elem.constante = 1;
						if(buscarElemento(&pila,elem)!=0){
							printf("\nERROR: Linea %i: Simbolo '%s' indefinido, variable no declarada. \n \n", yylineno,$1);
						   	YYABORT;
						}
						elementos = retornaElemento(&pila,elem);
						$$ = elementos;
					}
		| aParen Expresion cParen	{$$ = $2;}
	    ;

Tipo : tipoI	{$$ = "int"; tipoCorriente = "int";}
     | tipoF	{$$ = "float"; tipoCorriente = "float";}
	 ;

%%

yywrap(){
}

yyerror(){
	printf("\n");
	reportarToken(yytext);
	printf("\n");	
}

// Metodo principal.
void main(int argc, char* argv[]){
	char* archivo;
	archivo = argv[1];
	if(argc != 2){
		printf("\nUso incorrecto del compilador, hay mas parametros de los esperados. \n");
		printf("Debe usarse de la forma <compilador> <archivo>. \n\n");
	}
	else{
	    yyin = fopen(archivo,"r");
		InitValoresMain();
		if (yyin == NULL)
			printf("No se encontró el archivo indicado. \n");
		else{
			if (yyparse() == 0){ 
				printf(" \n");	
				printf ("Analisis Terminado Correctamente \n");
				printf(" \n");	
			}	
		}
	
		char* archivo_aux = (char*) malloc(sizeof(char)*50);
		int longx = strlen(archivo)-4;
		char aux[50] = {};
		archivo_aux = strncpy(aux, archivo,longx);
		generaAssembler(strcat(archivo_aux,".s"), nombreFuncion, codigo);
		
		char* archivo_aux2 = (char*) malloc(sizeof(char)*50);
		int longx2 = strlen(archivo)-4;
		char aux1[50]={};
        archivo_aux2 = strncpy(aux1, archivo, longx2);
		generarmain(strcat(archivo_aux2, ".c"), nombreFuncion, tipoRetProgram);
		
		fclose(yyin);
	}
}

// Metodo main utilizado eventualmente para realizar prubas rapidas.
/*void main(){
    yyin = fopen("test.c--","r");
	if (yyin == NULL)
		printf("ARCHIVO NULL \n");
	else{
		if (yyparse() == 0){ 
			printf(" \n");	
			printf ("Analisis Terminado Correctamente \n");
			printf(" \n");	
		}	
	}
	generaAssembler("test.s", nombreFuncion, codigo);
	fclose(yyin);
}*/
